With the widespread use of wide area network based applications, transmitting larger amounts of data from servers networked with requesting clients is necessary. Such files are typically obtained via remote access from the server via the wide area network between the requesting client and the server. Concerns have been raised with time delay in receiving a transfer of large amounts of data between networked computers.
Based on current network data transfer protocols such as the Common Internet File Sharing (CIFS) protocol or the Network File Sharing (NFS) protocol, data requests are typically broken up into different requests to send smaller increments of the data due to these local area network protocols for file transfer that are adapted to wide area networks. In such a situation, the client requesting the data will issue a single request for the first part of the requested file and wait for the receipt of the first part of the data. The client will then issue a subsequent request and wait for the receipt of the subsequent data and so forth until the entire data is received. The numerous requests across the network for large files create a long latency time to receive a requested file. In smaller, local area networks, such latency time between requests and sending data is small. However, in larger networks requiring remote access of files across long distances, the latency times increase and interfere with the efficient transfer of data over the network.
One solution to the latency time is to add acceleration modules to the client and the server. The acceleration modules may be implemented in either hardware or software. The acceleration module for the client includes a cache that holds requests received for the data. The acceleration module for the server includes prediction or read-ahead logic to determine other parts of the file that should be retrieved in the future based on the already received requests. Thus, when a first request is received, the acceleration module will attempt to predict the next request and begin to retrieve responsive data and send it to the cache of the acceleration module of the client. Once the first responsive data is received, the client will send the next request to the acceleration module for the client. The responsive data to the request is already stored in the cache of the client, thus eliminating the need for latency across the network for the second request to be sent to the client. However, if the prediction logic is inaccurate, the bandwidth of the network is unnecessarily used as well as consuming server resources in unnecessary data transfers and latency time is actually increased.
Thus, the read-ahead logic attempts to correctly predict offsets which when determined correctly achieve a performance gain. Ideally, large files may be sent sequentially and subsequent sequential blocks may be sent and thus accessed from the cache for the accelerator coupled to the client therefore minimizing the traffic and speeding performance. However, if the read-ahead logic is inaccurate as to the next requested data, the predictions impair performance by generating unnecessary input and output operations, generating unnecessary network traffic leading to blocking problems and wastefully occupying memory pages. Such a situation occurs when a data is not stored sequentially resulting in wasted resources by inaccurately predicting the next sequential block. For example, the first block in many files will contain a header with pointers to various locations in the sequence to fill in the file via data in different, non-linear locations in the file. Such files could not be accelerated because they are not requested sequentially.